﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Drawing;

namespace Djs.Tools.FileCommander.Components
{
    public class PicLibrary16
    {
        #region Image File
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku file.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu File_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property File, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property File_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\FileCmdWf\FileCmdWf\bmp\file.png
        /// </remarks>
        public static System.Drawing.Image File_Cached
        {
            get
            {
                if (_File == null) _File = File;
                return _File;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku file.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image File_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití File_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property File_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\FileCmdWf\FileCmdWf\bmp\file.png
        /// </remarks>
        public static System.Drawing.Image File { get { return _ImageCreateFrom(_File_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru file.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití File_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property File_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\FileCmdWf\FileCmdWf\bmp\file.png
        /// </remarks>
        public static System.Drawing.Image File_FromFile { get { return _ImageCreateFrom(_File_string, "file.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru File
        /// </summary>
        /// <returns></returns>
        private static string _File_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(808);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAQAAAC1+jfqAAAAAmJLR0QAAKqNIzIAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAAJdnBBZwAAABAAAAAQAFzGrcMAAACSSURB");
            sb.Append("VCjPdZFRDgIhDETfsCTeQe/lhwfUxHu5h9hE6gdQurvYBEJh+pimMl4fQqjtAu43yGA8rkzivQLkmmyIhLz2y4LRBEZdBQEJEItzGsH8ojjrj6BnGgLzukFJaHjoNZFS");
            sb.Append("XJ7r895kjCCIJg+CMjHZbZ4Ix54y6CQo4ZMpITIyiEvrvM5inJzwXPej7iMD+AGJKCvUnBfjLwAAACV0RVh0Y3JlYXRlLWRhdGUAMjAwOS0xMS0yOFQxNzoxODoyOC0w");
            sb.Append("NzowMDGRsiwAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTAtMDItMTZUMjA6MTk6MjYtMDc6MDBsdCLdAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEwLTAxLTExVDA4OjQyOjM0");
            sb.Append("LTA3OjAwKmm1fwAAADV0RVh0TGljZW5zZQBodHRwOi8vY3JlYXRpdmVjb21tb25zLm9yZy9saWNlbnNlcy9MR1BMLzIuMS87wbQYAAAAJXRFWHRtb2RpZnktZGF0ZQAy");
            sb.Append("MDA2LTEwLTA5VDA4OjEyOjQ2LTA2OjAwnL3sYwAAABZ0RVh0U291cmNlAENyeXN0YWwgUHJvamVjdOvj5IsAAAAndEVYdFNvdXJjZV9VUkwAaHR0cDovL2V2ZXJhbGRv");
            sb.Append("LmNvbS9jcnlzdGFsL6WRk1sAAAAASUVORK5CYII=");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property File_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void File_Reset()
        {
            _File = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití File_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _File = null;
        #endregion
        #region Image Filter
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku filter.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu Filter_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property Filter, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property Filter_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\FileCmdWf\FileCmdWf\bmp\filter.png
        /// </remarks>
        public static System.Drawing.Image Filter_Cached
        {
            get
            {
                if (_Filter == null) _Filter = Filter;
                return _Filter;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku filter.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image Filter_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Filter_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Filter_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\FileCmdWf\FileCmdWf\bmp\filter.png
        /// </remarks>
        public static System.Drawing.Image Filter { get { return _ImageCreateFrom(_Filter_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru filter.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Filter_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Filter_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\FileCmdWf\FileCmdWf\bmp\filter.png
        /// </remarks>
        public static System.Drawing.Image Filter_FromFile { get { return _ImageCreateFrom(_Filter_string, "filter.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru Filter
        /// </summary>
        /// <returns></returns>
        private static string _Filter_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(5308);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAALGOfPtRkwAACj1pQ0NQaWNjAAB42p1TZ1RT6RY99970QkuIgJRLb1IVCCBSQouAVGmiEpIA");
            sb.Append("oYQYEkDsiKjAiKIighUZFHHA0RGQsSKKhUGx9wF5CCjj4Cg2VN4P3hp9s+a9N2/2r732OWed75x9PgBGYLBEmoWqAWRKFfKIAB88Ni4eJ3cDClQggQOAQJgtC4n0jwIA");
            sb.Append("4Pvx8OyIAB/4AgTgzW1AAABu2ASG4Tj8f1AXyuQKACQMAKaLxNlCAKQQADJyFTIFADIKAOykdJkCACUAAFseGxcPgGoBADtlkk8DAHbSJPcCALYoUyoCQKMAQCbKFIkA");
            sb.Append("0A4AWJejFIsAsGAAKMqRiHMBsJsAYJKhzJQAYO8AgJ0pFmQDEBgAYKIQC1MBCPYAwJBHRfAACDMBKIyUr3jSV1whzlMAAPCyZIvlkpRUBW4htMQdXF25eKA4N0OsUNiE");
            sb.Append("CYTpArkI52VlygTSxQCTMwMAgEZ2RIAPzvfjOTu4OjvbONo6fLWo/xr8i4iNi/+XP6/CAQEAhNP1RfuzvKwaAO4YALbxi5a0HaBlDYDW/S+ayR4A1UKA5qtfzcPh+/Hw");
            sb.Append("VIVC5mZnl5ubaysRC22FqV/1+Z8JfwFf9bPl+/Hw39eD+4qTBcoMBR4R4IMLszKylHI8WyYQinGbPx7x3y7883dMixAni+ViqVCMR0vEuRJpCs7LkookCkmWFJdI/5OJ");
            sb.Append("f7PsD5i8awBg1X4G9kJbULvKBuyXLiCw6IAl7AIA5HffgqnREAYAMQaDk3cPADD5m/8daBkAoNmSFBwAgBcRhQuV8pzJGAEAgAg0UAU2aIM+GIMF2IAjuIA7eIEfzIZQ");
            sb.Append("iII4WABCSIVMkEMuLIVVUAQlsBG2QhXshlqoh0Y4Ai1wAs7CBbgC1+AWPIBeGIDnMApvYBxBEDLCRFiINmKAmCLWiCPCRWYhfkgwEoHEIYlICiJFlMhSZDVSgpQjVche");
            sb.Append("pB75HjmOnEUuIT3IPaQPGUZ+Qz6gGMpA2ageaobaoVzUGw1Co9D5aAq6CM1HC9ENaCVagx5Cm9Gz6BX0FtqLPkfHMMDoGAczxGwwLsbDQrF4LBmTY8uxYqwCq8EasTas");
            sb.Append("E7uB9WIj2HsCicAi4AQbgjshkDCXICQsIiwnlBKqCAcIzYQOwg1CH2GU8JnIJOoSrYluRD4xlphCzCUWESuIdcRjxPPEW8QB4hsSicQhmZNcSIGkOFIaaQmplLST1EQ6");
            sb.Append("Q+oh9ZPGyGSyNtma7EEOJQvICnIReTv5EPk0+Tp5gPyOQqcYUBwp/pR4ipRSQKmgHKScolynDFLGqWpUU6obNZQqoi6mllFrqW3Uq9QB6jhNnWZO86BF0dJoq2iVtEba");
            sb.Append("edpD2is6nW5Ed6WH0yX0lfRK+mH6RXof/T1Dg2HF4DESGErGBsZ+xhnGPcYrJpNpxvRixjMVzA3MeuY55mPmOxWWiq0KX0WkskKlWqVZ5brKC1Wqqqmqt+oC1XzVCtWj");
            sb.Append("qldVR9SoamZqPDWB2nK1arXjanfUxtRZ6g7qoeqZ6qXqB9UvqQ9pkDXMNPw0RBqFGvs0zmn0szCWMYvHErJWs2pZ51kDbBLbnM1np7FL2N+xu9mjmhqaMzSjNfM0qzVP");
            sb.Append("avZyMI4Zh8/J4JRxjnBucz5M0ZviPUU8Zf2UxinXp7zVmqrlpSXWKtZq0rql9UEb1/bTTtfepN2i/UiHoGOlE66Tq7NL57zOyFT2VPepwqnFU49Mva+L6lrpRugu0d2n");
            sb.Append("26U7pqevF6An09uud05vRJ+j76Wfpr9F/5T+sAHLYJaBxGCLwWmDZ7gm7o1n4JV4Bz5qqGsYaKg03GvYbThuZG4016jAqMnokTHNmGucbLzFuN141MTAJMRkqUmDyX1T");
            sb.Append("qinXNNV0m2mn6Vszc7MYs7VmLWZD5lrmfPN88wbzhxZMC0+LRRY1FjctSZZcy3TLnZbXrFArJ6tUq2qrq9aotbO1xHqndc804jTXadJpNdPu2DBsvG1ybBps+mw5tsG2");
            sb.Append("BbYtti/sTOzi7TbZddp9tneyz7CvtX/goOEw26HAoc3hN0crR6FjtePN6czp/tNXTG+d/nKG9QzxjF0z7jqxnEKc1jq1O31ydnGWOzc6D7uYuCS67HC5w2Vzw7il3Iuu");
            sb.Append("RFcf1xWuJ1zfuzm7KdyOuP3qbuOe7n7QfWim+UzxzNqZ/R5GHgKPvR69s/BZibP2zOr1NPQUeNZ4PvEy9hJ51XkNelt6p3kf8n7hY+8j9znm85bnxlvGO+OL+Qb4Fvt2");
            sb.Append("+2n4zfWr8nvsb+Sf4t/gPxrgFLAk4EwgMTAocFPgHb4eX8iv54/Odpm9bHZHECMoMqgq6EmwVbA8uC0EDZkdsjnk4RzTOdI5LaEQyg/dHPoozDxsUdiP4aTwsPDq8KcR");
            sb.Append("DhFLIzojWZELIw9GvonyiSqLejDXYq5ybnu0anRCdH302xjfmPKY3li72GWxV+J04iRxrfHk+Oj4uvixeX7zts4bSHBKKEq4Pd98ft78Swt0FmQsOLlQdaFg4dFEYmJM");
            sb.Append("4sHEj4JQQY1gLImftCNpVMgTbhM+F3mJtoiGxR7icvFgskdyefJQikfK5pThVM/UitQRCU9SJXmZFpi2O+1temj6/vSJjJiMpkxKZmLmcamGNF3akaWflZfVI7OWFcl6");
            sb.Append("F7kt2rpoVB4kr8tGsudntyrYCpmiS2mhXKPsy5mVU53zLjc692ieep40r2ux1eL1iwfz/fO/XUJYIlzSvtRw6aqlfcu8l+1djixPWt6+wnhF4YqBlQErD6yirUpf9VOB");
            sb.Append("fUF5wevVMavbCvUKVxb2rwlY01CkUiQvurPWfe3udYR1knXd66ev377+c7Go+HKJfUlFycdSYenlbxy+qfxmYkPyhu4y57JdG0kbpRtvb/LcdKBcvTy/vH9zyObmLfiW");
            sb.Append("4i2vty7ceqliRsXubbRtym29lcGVrdtNtm/c/rEqtepWtU910w7dHet3vN0p2nl9l9euxt16u0t2f9gj2XN3b8De5hqzmop9pH05+57WRtd2fsv9tr5Op66k7tN+6f7e");
            sb.Append("AxEHOupd6usP6h4sa0AblA3DhxIOXfvO97vWRpvGvU2cppLDcFh5+Nn3id/fPhJ0pP0o92jjD6Y/7DjGOlbcjDQvbh5tSW3pbY1r7Tk++3h7m3vbsR9tf9x/wvBE9UnN");
            sb.Append("k2WnaKcKT02czj89dkZ2ZuRsytn+9oXtD87FnrvZEd7RfT7o/MUL/hfOdXp3nr7ocfHEJbdLxy9zL7dccb7S3OXUdewnp5+OdTt3N191udp6zfVaW8/MnlPXPa+fveF7");
            sb.Append("48JN/s0rt+bc6rk99/bdOwl3eu+K7g7dy7j38n7O/fEHKx8SHxY/UntU8Vj3cc3Plj839Tr3nuzz7et6EvnkQb+w//k/sv/xcaDwKfNpxaDBYP2Q49CJYf/ha8/mPRt4");
            sb.Append("Lns+PlL0i/ovO15YvPjhV69fu0ZjRwdeyl9O/Fb6SvvV/tczXrePhY09fpP5Zvxt8Tvtdwfec993foj5MDie+5H8sfKT5ae2z0GfH05kTkz8EwOY8/wlYzOiAAAAIGNI");
            sb.Append("Uk0AAHolAACAgwAA+f8AAIDpAAB1MAAA6mAAADqYAAAXb5JfxUYAAAAGYktHRAAAAAAAAPlDu38AAAAJcEhZcwAACxMAAAsTAQCanBgAAAAJdnBBZwAAABAAAAAQAFzG");
            sb.Append("rcMAAAM5SURBVDjLfZLba1N3AMe/v3PLueU0SRNdpE2jqdap2Ypg3bLLyx6EXfBxjrm9DHzYi2OI/4A++DwGQ2QPQxZBfK1tnSLKGHYXWJs0qSEmNUlDlTSnuZxrzjm/");
            sb.Append("PYxuyGTfpy984QPfL19y9bvrYBgG7c1NLC4uHo4lEl+8+/Zb76mqsicUCnEsyxLTsgFKvcGgVymWHt+tVSpLBzKZtSNHj1nk2tUfASAzGA6/FkPCqTOfnskYho3/052F");
            sb.Append("+R19p/eL6/jfcl1dRxAEn+dyuS+zrx/FjRs3sbX1DJo2hvh4GKZlo1CoIqLJ0MZEEEbA2bOfRbY7z97PX8/PsZOpw2g1W9P7JlMfTk+nSXRMgu+PoCoCJCmEkMBClAQk");
            sb.Append("kzEkk6/g5FwOpmlg6fYSlh8t97hYLKpaAplYWVkhuTdPIPvaERzLvop2uwN9p4dYNIp4PALTcrBRbwEAvr/2A1ZXV61Bv3uBMS3zXObQwXe0cPjh4sI96LoDAGhtNvH7");
            sb.Append("HwWsV2oI6L/9b92aR6PZQm/Qu6L3+nnm+fPO3n2p9Aezx4+f+unOvW9KpSqCgEANa7AsA/q2jk5ngLXSBv5cfQxd78I0hncd274SUB9cNBJNH9g/eYFnQ20tok3Mz9/u");
            sb.Append("ZrMzsUQiCQJg5I3gOC54nofrOOj3dvoAzu9J7HWDIA4m8L1LlXLlRKFQ/Jhhab5YLH1ULJTt8ZiCqakUbNuE53lgGYJ67Yk3HPS/YhimJIoSFEUFFwRB0fO80yAMfN8H");
            sb.Append("x7F48ODny6mpicszh2bQbDRg2RZqtTqeVKs3fd/LA0AQ+AAAdnb2DaTTKYAQ1Osb8EYeCGGWbcs9OZVKZba722g8bWD50W9V0zBOi6JkiKIIWZYhyzKY3XUppVAUBeGw");
            sb.Append("CoHn3fL6+sVCcW0zvT+DanXDaTaenhd4vsexLASBhyAIEAQB3C7A931EI1GosgpKA7ius1Iqlx+OJ8Y/abW3fh35wX3Ddv5zaw4ACAEICFRVxd8OoKCQJYnjeQ6Kog0V");
            sb.Append("JUxB8HLAYGiAIRwkSQQh5J9KsixK2lgY8URcpjRgd7MXAKqqIhKNg1KKF3IKcDy30G5vzcmKfH/kuvbLAH8BQLpsxF+EU7sAAAAldEVYdGNyZWF0ZS1kYXRlADIwMDkt");
            sb.Append("MTEtMjhUMTc6MTg6MjgtMDc6MDAxkbIsAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEwLTAxLTExVDA4OjQyOjUyLTA3OjAw/osxfgAAACV0RVh0ZGF0ZTptb2RpZnkAMjAx");
            sb.Append("MC0wMS0xMVQwODo0Mjo1Mi0wNzowMI/WicIAAAA1dEVYdExpY2Vuc2UAaHR0cDovL2NyZWF0aXZlY29tbW9ucy5vcmcvbGljZW5zZXMvTEdQTC8yLjEvO8G0GAAAACV0");
            sb.Append("RVh0bW9kaWZ5LWRhdGUAMjAwOS0xMS0yOFQxNDozMTozMi0wNzowMB9JZQ0AAAAWdEVYdFNvdXJjZQBDcnlzdGFsIFByb2plY3Tr4+SLAAAAJ3RFWHRTb3VyY2VfVVJM");
            sb.Append("AGh0dHA6Ly9ldmVyYWxkby5jb20vY3J5c3RhbC+lkZNbAAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property Filter_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void Filter_Reset()
        {
            _Filter = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití Filter_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _Filter = null;
        #endregion
        #region Image Folder
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku folder.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu Folder_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property Folder, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property Folder_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\FileCmdWf\FileCmdWf\bmp\folder.png
        /// </remarks>
        public static System.Drawing.Image Folder_Cached
        {
            get
            {
                if (_Folder == null) _Folder = Folder;
                return _Folder;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku folder.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image Folder_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Folder_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Folder_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\FileCmdWf\FileCmdWf\bmp\folder.png
        /// </remarks>
        public static System.Drawing.Image Folder { get { return _ImageCreateFrom(_Folder_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru folder.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Folder_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Folder_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\FileCmdWf\FileCmdWf\bmp\folder.png
        /// </remarks>
        public static System.Drawing.Image Folder_FromFile { get { return _ImageCreateFrom(_Folder_string, "folder.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru Folder
        /// </summary>
        /// <returns></returns>
        private static string _Folder_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1184);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAAAZiS0dEAAAAAAAA+UO7fwAAAAlwSFlzAAAASAAAAEgARslrPgAAAAl2cEFn");
            sb.Append("AAAAEAAAABAAXMatwwAAAXBJREFUOMuVk7tOAkEUhr9dMUbL9QHodRsrbNXwBD4A4a0sTLazsKGyJFQaqbCAWGiDNXIREXZ35hyLvXBZjfgnp5hM/m/+c2bGAVw/8Cwb");
            sb.Append("6taHx8ALIEBhP5cfeDqTaaH8wFPgHDgASmntAM6qvwTwHHUK4HatT4Vy869kJYCpjgEQFVzHRVR4XDRp1/oFcIVyr1sfngH3OWBkB7yZV64bV2wjP/BaGSQByIDrxtWP");
            sb.Append("J/6mCuVWtz48zQEAnfAhaQWLxRBrTKwRMSGRhgjC3dcN1f3LjFMtAUzknWwWLi5GDYbEnBgtsUYYYuY641MmGeAwBQwTgIwRBFHJU0Qa5iCTrj9knAGcDcAERVCUWCMs");
            sb.Append("llAXGI2xGEza0lxn6+9gIiOWs1CAtTYEi1GTJyoAvvST1SSgucFisWoQBACLYaHzzL9wgCM/8Hpb39/yRd4CDQfYBU6AC8Db0j8HnoBm9jEcYC+FbSMLRIBxVPW/6df0");
            sb.Append("Db8lCnHO4qVnAAAAJXRFWHRjcmVhdGUtZGF0ZQAyMDA5LTExLTE1VDE2OjA4OjQxLTA3OjAwJK7h4AAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMC0wMi0yMFQyMzoyNDo0");
            sb.Append("Ny0wNzowMN2xk/EAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTAtMDEtMTFUMDk6MTg6MzItMDc6MDDyWmVLAAAANXRFWHRMaWNlbnNlAGh0dHA6Ly9jcmVhdGl2ZWNvbW1v");
            sb.Append("bnMub3JnL2xpY2Vuc2VzL0xHUEwvMi4xLzvBtBgAAAAldEVYdG1vZGlmeS1kYXRlADIwMDktMTEtMTVUMTY6MDg6NDEtMDc6MDB7H5fUAAAAGXRFWHRTb2Z0d2FyZQBB");
            sb.Append("ZG9iZSBJbWFnZVJlYWR5ccllPAAAAA10RVh0U291cmNlAE51dm9sYaxPNfEAAAA0dEVYdFNvdXJjZV9VUkwAaHR0cDovL3d3dy5pY29uLWtpbmcuY29tL3Byb2plY3Rz");
            sb.Append("L251dm9sYS92PbRSAAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property Folder_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void Folder_Reset()
        {
            _Folder = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití Folder_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _Folder = null;
        #endregion
        #region Image Previous
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku previous.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu Previous_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property Previous, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property Previous_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\FileCmdWf\FileCmdWf\bmp\previous.png
        /// </remarks>
        public static System.Drawing.Image Previous_Cached
        {
            get
            {
                if (_Previous == null) _Previous = Previous;
                return _Previous;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku previous.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image Previous_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Previous_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Previous_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\FileCmdWf\FileCmdWf\bmp\previous.png
        /// </remarks>
        public static System.Drawing.Image Previous { get { return _ImageCreateFrom(_Previous_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru previous.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Previous_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Previous_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\FileCmdWf\FileCmdWf\bmp\previous.png
        /// </remarks>
        public static System.Drawing.Image Previous_FromFile { get { return _ImageCreateFrom(_Previous_string, "previous.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru Previous
        /// </summary>
        /// <returns></returns>
        private static string _Previous_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1536);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABmJLR0QAAAAAAAD5Q7t/AAAACXBIWXMAAEnSAABJ0gGoRYr4AAAACXZwQWcAAAAQAAAAEABcxq3DAAAC");
            sb.Append("eUlEQVQ4y62TTUhUURTH//e9+54zb9SZsbTJhmhKF2MJhWlluak2BS6NqIVCtGoT9l0U0dIKjBAM3LWKdi0kkMBaFJXgRmSkMmXwY8am+XJ8792Pd1uoaCi1qLM73P/5");
            sb.Append("3XPO/17gH4P86fDYNR3ZojL8ZUTqBN7HXrlBo21a2Qhc6I8jaNVG98b23A4GAjv8Pt+m0g2A8BGgr78D6VQp3tJ4dKAp3tZlUr/hM61NAXR9Un0GSL9QONvT0Nq6/3hv");
            sb.Append("TXVNcy6fndGIFvUUkafuRTQpubLZ4gIhpPSux1nbQUMnxfig0DrvHGjfV9/0KBQK1bmyBEhN5AqZeeFxLjxGOBdyKjnZXWFVvhq49Hm5g0OX/Ziesc2L9w931cfiD/zl");
            sb.Append("xraSyEAqAQ+CkgCLemwJjC+B6j7P8gUqKsvDyyO0XqEYTdjGudMHr8Z27b6lTKd8kZegUQVBGGxZgM2KcJkLwSUsskUppeApubYDqkFJKWXeXlAO+wliSCjK4KoCXK8E");
            sb.Append("wQUE88AdhaAmIaRBqOUtu/D+sUDzSVO87Bt9OjE2edNZ5PN5PoesmAanBRg+oMwyYPooqEkA4hHuSuNhRzcAQAeA768l4RnQxHD2S6jWnIpEIo3+sFal+TiqaEySfOiH");
            sb.Append("wUK5MhkuaMzKZlK5wfMn+sfX26gASADiTV9yqJBxsi3tO+8G6wItMk8zb59/vVFMsSkzoDHqV3YhaydX3dPXPQNvBaJmx5ZmHWF/qI1ujxjE2poYST5LDC0mFr6586kE");
            sb.Append("m8tNe6WVS38DrEI4AJ6ecFJ6pTtsi3zRcZdGZkdFGgADIFaL//qZ2q7rmJtVejBIPJ1CfXoi8d/jF/WDLHsUzISlAAAAJXRFWHRjcmVhdGUtZGF0ZQAyMDA5LTEyLTA4");
            sb.Append("VDEzOjE2OjA0LTA3OjAwHQ6TbgAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMC0wMi0yMFQyMzoyNjoxNS0wNzowMAY7XIEAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTAtMDEt");
            sb.Append("MjZUMTc6NTQ6MTYtMDc6MDAnX5seAAAAMnRFWHRMaWNlbnNlAGh0dHA6Ly9lbi53aWtpcGVkaWEub3JnL3dpa2kvUHVibGljX2RvbWFpbj/96s8AAAAldEVYdG1vZGlm");
            sb.Append("eS1kYXRlADIwMDktMTItMDhUMTM6MTY6MDQtMDc6MDBCv+VaAAAAGXRFWHRTb2Z0d2FyZQB3d3cuaW5rc2NhcGUub3Jnm+48GgAAABl0RVh0U291cmNlAFRhbmdvIElj");
            sb.Append("b24gTGlicmFyeVTP7YIAAAA6dEVYdFNvdXJjZV9VUkwAaHR0cDovL3RhbmdvLmZyZWVkZXNrdG9wLm9yZy9UYW5nb19JY29uX0xpYnJhcnm8yK3WAAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property Previous_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void Previous_Reset()
        {
            _Previous = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití Previous_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _Previous = null;
        #endregion
        #region Image Refresh
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku refresh.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu Refresh_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property Refresh, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property Refresh_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\FileCmdWf\FileCmdWf\bmp\refresh.png
        /// </remarks>
        public static System.Drawing.Image Refresh_Cached
        {
            get
            {
                if (_Refresh == null) _Refresh = Refresh;
                return _Refresh;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku refresh.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image Refresh_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Refresh_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Refresh_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\FileCmdWf\FileCmdWf\bmp\refresh.png
        /// </remarks>
        public static System.Drawing.Image Refresh { get { return _ImageCreateFrom(_Refresh_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru refresh.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Refresh_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Refresh_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\FileCmdWf\FileCmdWf\bmp\refresh.png
        /// </remarks>
        public static System.Drawing.Image Refresh_FromFile { get { return _ImageCreateFrom(_Refresh_string, "refresh.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru Refresh
        /// </summary>
        /// <returns></returns>
        private static string _Refresh_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1800);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABmJLR0QAAAAAAAD5Q7t/AAAACXBIWXMAAAG7AAABuwE67OPiAAAACXZwQWcAAAAQAAAAEABcxq3DAAAD");
            sb.Append("I0lEQVQ4y22Tz2tcVRzFz/e+e9+vSWaSTlKTTkKbDG1j0DihtDYKofUHhRbHP6AUWty6UXDpqqIbBd2JG8GdCwkOKBqLotRCKkZNSoLaNolp0nTsJHmZzpv33n33fd0Y");
            sb.Append("GMGz/nA2n3OImdEZqlIZAhetLuu5kdLIZLGrKFY2V5bqW/VrMPiYa3z7X24IgKT9AqqSAOG14mjxrQsnL7il/hIG+wZhCQtBEODO/TuYuTETba9tX0WGnwql/GdxEEfE");
            sb.Append("zKAqCeHQd1OnT0+dnXxeCVvg/2ISgxsL1/Vv67/SlRdekR98+j4kAJDA65WxJ6ZOjj2tgjAAhYRGo4GN+xsgJpSHy/B6PADAxNGKmihXkDFDgCCpSsf7B3quHj0yrhq7");
            sb.Append("DZjUYP6Xefy58gcco+DZHq7P/YDeUhGnTpxCb74XYMBiC4IEJBEulQpDTitqoRW1sHhrEX/XNznnqiRM9LU408YX6txu1LBnV2dpenwaLrughGARQTq+OssGtL27jb1g");
            sb.Append("Dxv31uH7qr3Xjp/iGt+mKk3Cwov8JNFjhw+iKZtoP2oj2AlAGVgqR1Qio5EGAeoP67CMQCvR3+zr6vLcPpUXnur1kD6IsRbcRfNBE9zKkEbmK/IvqiRrWQoS0I6G0oQk");
            sb.Append("MbNmJjvXsQ0XQEHBIhCbjNgYZs2fc1MksbmJMEWkIpiiAY8CjmtNU5WOdxg8JIg+oQnqM5VMqmFLd+edCABkmmRfurZ6BgdSQh+QdWco5pVDS+Jn8TJ9ASJybHm+MOzO");
            sb.Append("pUPZmVjTalRIN61lsUVXaJPwEh73XDWPEbjJQApf2cg5NorSh24YtkDwBmQaUvpXpNPFMEmWdTNba/+uv25/pFcF13i5Hek3/R2lXang2RI5R0H6hNwxm6wJQUl/pnK+");
            sb.Append("Xe5y7PGC7Y/FC+aNaCs9AgD7m32vsRV+23PXjXuEB1cpUI6wdzDCzqE2dgcjNPtj5KVTbt9KzoS7yRKA7wGg80wE4NXuA+473qj0SmN5ER1L0SomsO4JPJxrsbmZheEj");
            sb.Append("/TaAd7nGyX8KOpQdBnAZwLOWoBPMoIx5AcCPAD7kGq938v8AUXJrHm3vh9oAAAAldEVYdGNyZWF0ZS1kYXRlADIwMDktMTEtMTVUMTc6MDI6MzQtMDc6MDC2544SAAAA");
            sb.Append("JXRFWHRkYXRlOmNyZWF0ZQAyMDEwLTAxLTExVDA5OjI0OjQ1LTA3OjAwz7ts7wAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMC0wMS0xMVQwOToyNDo0NS0wNzowML7m1FMA");
            sb.Append("AABndEVYdExpY2Vuc2UAaHR0cDovL2NyZWF0aXZlY29tbW9ucy5vcmcvbGljZW5zZXMvYnktc2EvMy4wLyBvciBodHRwOi8vY3JlYXRpdmVjb21tb25zLm9yZy9saWNl");
            sb.Append("bnNlcy9MR1BMLzIuMS9bjzxjAAAAJXRFWHRtb2RpZnktZGF0ZQAyMDA5LTA2LTAzVDA5OjU4OjE0LTA2OjAw6T1b2QAAABl0RVh0U29mdHdhcmUAd3d3Lmlua3NjYXBl");
            sb.Append("Lm9yZ5vuPBoAAAATdEVYdFNvdXJjZQBPeHlnZW4gSWNvbnPsGK7oAAAAJ3RFWHRTb3VyY2VfVVJMAGh0dHA6Ly93d3cub3h5Z2VuLWljb25zLm9yZy/vN6rLAAAAAElF");
            sb.Append("TkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property Refresh_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void Refresh_Reset()
        {
            _Refresh = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití Refresh_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _Refresh = null;
        #endregion
        #region Image Text
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku text.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu Text_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property Text, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property Text_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\FileCmdWf\FileCmdWf\bmp\text.png
        /// </remarks>
        public static System.Drawing.Image Text_Cached
        {
            get
            {
                if (_Text == null) _Text = Text;
                return _Text;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku text.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image Text_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Text_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Text_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\FileCmdWf\FileCmdWf\bmp\text.png
        /// </remarks>
        public static System.Drawing.Image Text { get { return _ImageCreateFrom(_Text_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru text.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Text_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Text_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\FileCmdWf\FileCmdWf\bmp\text.png
        /// </remarks>
        public static System.Drawing.Image Text_FromFile { get { return _ImageCreateFrom(_Text_string, "text.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru Text
        /// </summary>
        /// <returns></returns>
        private static string _Text_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1372);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABmJLR0QAAAAAAAD5Q7t/AAAACXBIWXMAAAG7AAABuwE67OPiAAAACXZwQWcAAAAQAAAAEABcxq3DAAAB");
            sb.Append("4klEQVQ4y5WRzU5bMRBGz8y9jvNT9YKyQEkDXcC6XSBehC54gr5dKuUBeIJ2VxYg0UUjhAiimyhNE3JtTxc3SVMSVaolS7as78yZsZgZIvIWOOX/1lcz+5YvL6fz+fOn");
            sb.Append("xeIZEUUERASpDsiLZJ7nOOc+AGsA4/GYmCJPTz+ouZxkhnOOn5MJjWYTEaFRr7O3t1eBV7DVoQwlzjm63Q6qioogqhwcHFQ2sA7uBFhKqCrD4ZBXrRaI0Gq1+DWd4r1H");
            sb.Append("VSlDIM8yut3uNqAoCsoQODk+RlWRpUW73a5sNqrvNEhLg9FohPeeGCOIEEMgpUSj0WB/f5/mch5bgBACrlbjTa+HipBlGaq6s+pfP/JniAHvPaOHB0IIZFmG955NQzND");
            sb.Append("VTk6OtoGrPrs9XrVDER2GpjZboPXRUFKifv7e2q1GqpKnueklJhOp+R5XrXpHJ1Ox7YA89kM7z2Hh4drg9WOMTKZTHh8fCSlxGAw+AJcbw2xXq9ze3tLURTEGGk2m2uD");
            sb.Append("u7s7zs7OuLy8HF5cXHwEbjZ7On8YjWw2m9lisbCyLC2EYCklCyHYeDy2q6srGwwG351z7wExsyq7AoQY18EYo8UYLaVkMUabz+ep3+9/Bt5ths2suojIyfLxX+sauLEX");
            sb.Append("3/AbvvT5GoC/kcsAAAAldEVYdGNyZWF0ZS1kYXRlADIwMDktMTEtMTVUMTc6MDI6MzMtMDc6MDBzQLCcAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEwLTAxLTExVDA5OjI0");
            sb.Append("OjEzLTA3OjAw5ItXsQAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMC0wMS0xMVQwOToyNDoxMy0wNzowMJXW7w0AAABndEVYdExpY2Vuc2UAaHR0cDovL2NyZWF0aXZlY29t");
            sb.Append("bW9ucy5vcmcvbGljZW5zZXMvYnktc2EvMy4wLyBvciBodHRwOi8vY3JlYXRpdmVjb21tb25zLm9yZy9saWNlbnNlcy9MR1BMLzIuMS9bjzxjAAAAJXRFWHRtb2RpZnkt");
            sb.Append("ZGF0ZQAyMDA5LTAzLTE5VDEwOjUyOjUyLTA2OjAwToDnmwAAABl0RVh0U29mdHdhcmUAd3d3Lmlua3NjYXBlLm9yZ5vuPBoAAAATdEVYdFNvdXJjZQBPeHlnZW4gSWNv");
            sb.Append("bnPsGK7oAAAAJ3RFWHRTb3VyY2VfVVJMAGh0dHA6Ly93d3cub3h5Z2VuLWljb25zLm9yZy/vN6rLAAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property Text_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void Text_Reset()
        {
            _Text = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití Text_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _Text = null;
        #endregion

        #region SPOLEČNÉ METODY PRO KONVERZI
        /// <summary>
        /// Vrátí Image z definice (string). Image generuje buď v paměti, anebo s pomocí souboru.
        /// Pokud není zadán parametr (cacheFileName) (když je null), generuje se Image v paměti.
        /// Pokud je soubor (cacheFileName) definován, pak se Image čte z něj.
        /// Pokud soubor neexistuje, nejprve se vytvoří.
        /// Umístění souboru (adresář) je dán property _ImageCacheDir, defaultně je to adresář (Sys:\Documents and Settings\All Users\Data aplikací\IconCache).
        /// Obsah obrázku definuje metoda getDataMethod.
        /// </summary>
        /// <param name="getDataMethod"></param>
        /// <param name="cacheFileName"></param>
        /// <returns></returns>
        private static System.Drawing.Image _ImageCreateFrom(_GetStringDelegate getDataMethod, string cacheFileName)
        {
            System.Drawing.Image image;
            if (cacheFileName == null)
            {
                using (System.IO.MemoryStream ms = new System.IO.MemoryStream(Convert.FromBase64String(getDataMethod())))
                {
                    image = System.Drawing.Image.FromStream(ms);
                }
                return image;
            }
            string fileName = System.IO.Path.Combine(_ImageCacheDir, cacheFileName);
            if (!System.IO.File.Exists(fileName))
                System.IO.File.WriteAllBytes(fileName, Convert.FromBase64String(getDataMethod()));
            if (System.IO.File.Exists(fileName))
                return Image.FromFile(fileName);
            return null;
        }
        /// <summary>
        /// Obsahuje jméno adresáře, který slouží jako Cache pro obrázky systému.
        /// </summary>
        private static string _ImageCacheDir
        {
            get
            {
                if (__ImageCacheDir == null)
                {
                    string path = Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData, Environment.SpecialFolderOption.Create);
                    path = System.IO.Path.Combine(path, "FileCommander", "Pics16");
                    if (!System.IO.Directory.Exists(path))
                        System.IO.Directory.CreateDirectory(path);
                    __ImageCacheDir = path;
                }
                return __ImageCacheDir;
            }
        } private static string __ImageCacheDir;
        /// <summary>
        /// Předpis pro metody, které generují obsah souboru s daty
        /// </summary>
        /// <returns></returns>
        private delegate string _GetStringDelegate();
        /// <summary>
        /// Vrátí Icon z dat (string), která jsou předána na vstup v kódování Base64
        /// </summary>
        /// <param name="data">Vstupní data v kódování Base64</param>
        /// <returns>Icon vytvořená z dat</returns>
        public static System.Drawing.Icon ConvertStringToIcon(string data)
        {
            System.Drawing.Icon icon;
            using (System.IO.MemoryStream ms = new System.IO.MemoryStream(Convert.FromBase64String(data)))
            {
                icon = new System.Drawing.Icon(ms);
            }
            return icon;
        }
        /// <summary>
        /// Vrátí Cursor z dat (string), která jsou předána na vstup v kódování Base64
        /// </summary>
        /// <param name="data">Vstupní data v kódování Base64</param>
        /// <returns>Cursor vytvořený z dat</returns>
        public static System.Windows.Forms.Cursor ConvertStringToCursor(string data)
        {
            System.Windows.Forms.Cursor cursor;
            using (System.IO.MemoryStream ms = new System.IO.MemoryStream(Convert.FromBase64String(data)))
            {
                cursor = new System.Windows.Forms.Cursor(ms);
            }
            return cursor;
        }
        #endregion
    }
}
